测试阶段

人员角色

任务

时间

工作成果

工作角色

具体职责

工作角色

具体职责

void example fun(int length)//length为用户的输入数据

char x buffer;

if(length<0)//没有验证length是否超出内存分配的上限

return 0;

buffer =(char)malloc(sizeof(char)*length);

free(buffer);

buffer = NULL;

const int MAX LENGTH=1024; //指定内存分配的上限或动态判断剩余内存大小自动分配

void example fun(int length)//length为用户的输入数据

char * buffer:

if(length>MAX LENGTH || length<0)//对length进行验证

return 0;

buffer =(char)malloc(sizeof(char)*length);

if(buffer!= NULL)

···

free(buffer);

buffer = NULL;

#include<stdio.h)

#include<string.h)

void example fun(void)

//攻击者可在搜索优先级更高的文件夹中放入和dir同名的恶意程序导致command的内容无法正确执行 system(command);//本例中command ="dir.exe E:\\data"

·

#include<stdio.h)

#include<string.h)

void example fun(void)

//PATH是存放操作系统中dir命令所在完整路径的常量，本例中PATH="C:\WINDOWS\\system32\\"

char cmd[MAX SIZE]=PATH; //使用完整路径确保command的内容能正确执行

strcat(cmd,command);//本例中command="dir.exe E:\\data"

system(cmd);

#include<stdio.h)

#include<string.h)

void example fun(const char* filename)//filename为用户的输入数据，不超过10个字符

FILE *file; //待访问的文件

char path[32]="C:\\data\\";//待访问文件的路径

strcat(path,filename);//filename可能包含".."字符序列导致访问"C:\\data\\"目录之外的文件

file = fopen(path,"r");

·

#include<stdio.h)

#include<string.h)

int verification(const char* str)//验证str是否合法，函数仅供参考

{

//设置白名单

char whitelist[MAX SIZE][16]={"A001.txt","A002.txt",.};

· ·

int flag =0;

int i;

//循环比较str是否在白名单内

for(i=0;i<MAX SIZE;i++)

if(strcmp(whitelist[i],str)==0)

{

flag =1;

break;

return flag;

void example fun(const char* filename)//filename为用户的输入数据，不超过10个字符

FILE *file;//待访问的文件

char path[32]="C:\\data\\";//待访问文件的路径

if(verification(filename))

//文件名合法则将路径和文件名组合成完整的文件访问路径

strcat(path, filename);

file = fopen(path,"r");

#include<stdio.h)

#include<string.h)

void example fun(const char* absolutepath)//absolutepath为用户的输入数据

FILE *file;

file = fopen(absolutepath,"r");//攻击者可以访问任意文件或目录

#include(stdio.h)

#include<string.h)

int verification(const charx str)//验证str是否合法，函数仅供参考

//设置白名单

char userlist[MAX SIZE][16]={"A001.txt","A002.txt",.};

char whitelist[MAX SIZE][32];

int i;

for(i=0;i<MAX SIZE;i++)

strcpy(whitelist[i],PATH);//PATH是该应用程序允许访问路径的常量，本例中PATH="E:\

Users\\"

strcat(whitelist[i],userlist[i]);

…

int flag =0;

//循环比较str是否在白名单内

for(i=0;i<MAX SIZE;i++)

if(strcmp(whitelist[i],str)==0)

flag =1;

break;

return flag;

}

void example fun(const char* absolutepath)//absolutepath为用户的输入数据

{

FILE *file;

if(verification(absolutepath))

//路径合法则允许访问文件

file = fopen(absolutepath,"r");

#include <stdio.h>

#include<string.h)

void example fun(char* command)//command为用户输入数据，不超过31个字符

//PATH是存放操作系统中cmd.exe所在完整路径的常量，本例中PATH="C:\WINDOWS\\system32\\"

char cmd[128]= PATH;

strcat(cmd,"cmd.exe /c \"");

if(command!= NULL)//未对command进行验证，攻击者可执行delete等恶意命令

strcat(cmd, command);

strcat(emd,"\"");

system(cmd);

#include(stdio.h)

#include<string.h>

int verification(const char* permission, const char* str)//验证str是否合法，函数仅供参考

//设置白名单

char userlist[MAX SIZE][8]={"A001","A002",.};

char whitelist[MAX SIZE][32];

int i;

for(i=0;i<MAX SIZE;i++)

strepy(whitelist[i],permission);

streat(whitelist[i],userlist[i]);

int flag =0;

//循环比较str是否在白名单内

for(i=0;i<MAX SIZE;i++)

if(strcmp(whitelist[i],str)==0)

flag =1;

break;

return flag;

void example fun(char* command)//command为用户输入数据，不超过31个字符

{

//PATH是存放操作系统中cmd.exe所在完整路径的常量，本例中PATH="C:\WINDOWS\\system32\\"

char cmd[128]= PATH;

strcat(cmd,"emd.exe /c \"");

//本例假设用户只有查询权限，QUERY是限制查询目录的字符串常量，本例中QUERY="dir.exe E:\

Users\\"

if(verification(QUERY,command))

//命令合法则允许执行

strcat(cmd,command);

strcat(cmd,"\"");

system(cmd);

#include<stdio.h)

#include<string.h)

void sql query(char* name) //name为用户输入数据，不超过10个字符

//本例中userid是仅由字母和数字组成的长度不超过10位的字符串

char sqIQuery[64]="SELECT * FROM CUSTOMER WHERE userid=";

//拼接sql语句前未验证name是否合法

strcat(sqlQuery,name);

strcat(sqlQuery,"");

//在数据库中执行sqlQuery语句

#include<stdio.h)

#include<string.h)

#include<regex.h)

int verification(const char* str) //验证str是否合法，函数仅供参考

{

//设置白名单

char whitelist[MAX SIZE][8]={"A001","A002",.};

int flag =0;

inti=0;

//循环比较str是否在白名单内

for(i=0;i<MAX SIZE;i++)

f(strcmp(whitelist[i],str)==0)

flag =1;

break;

return flag;

void sqlquery(char* name)//name为用户输入数据，不超过10个字符

//本例中userid是仅由字母和数字组成的长度不超过10位的字符串

char sqlQuery[64]="SELECT FROM CUSTOMER WHERE userid='";

if(verification(name))//在拼接SQL语句前验证name是否合法

streat(sqlQuery,name);

streat(sqlQuery,"");

//在数据库中执行sqlQuery语句

#include(stdio.h)

#include "stdafx.h"

#include<string.h)

#include<malloc.h>

#include<string〉

using namespace std;

string to legal param(char* param)

string strSql(param);

string returnValue ="";

string::size type pos = 0;

for(inti=0;i<strSql.size();i++)

if (strSql[i]==↑)

returnValue+="";

else

returnValue+= strSql[i];

return returnValue;

void sqlquery(char* name)//name为用户输入数据，不超过10个字符

string sqlQuery ="SELECT x FROM CUSTOMER WHERE userid=";

//将参数name转换为合法的SQL字段值

string strName= to legal param(name);

sqlQuery += strName;

sqlQuery+="";

//在数据库中执行sqlQuery语句

#include<windows.h)

void load lib(char* libraryName)//libraryName为用户输入数据，不超过15个字符

char path[32]="C:\\";

strcat(path,libraryName);

//使用未经验证的输入数据作为动态加载的库可能导致加载恶意代码库

HANDLE hlib = LoadLibrary(path);

#include〈windows.h)

int verification(char*); //验证库文件，通过验证则返回1,否则返回0

void load lib(char* libraryName)//libraryName为用户输入数据，不超过15个字符

char path[32]="C:\\";

if(verification(libraryName)) //判断libraryName是否是合法的库

strcat(path,libraryName);

HANDLE hlib = LoadLibrary(path);

void example fun()

··

char value[11];//本例中假设只允许用户输入10个以下的字符

printf("Enter The Value:");

//攻击者可输入大于10个字符的字符串，覆盖栈原来的返回地址，造成缓冲区溢出

scanf("%s",value);

… ·

void example fun()

…

char value[11];//本例中假设只允许用户输入10个以下的字符

printf("Enter The Value:");

//从标准输入读取最多10个字符，并保存在value数组中

scanf("%10s",value);

void example fun(char* s) //s 为用户输入数据

printf(s); //s 中可能包含"%n"等格式控制符导致缓冲区溢出

void example fun(char* s)//s为用户输入数据

· ·

printf("%s",s);//传递一个不能由用户控制的静态格式化字符串

. .

unsigned int num; //本例中num值为1000

void example fun()

{

… ·

//本例代码假设是运行在32位的系统中，32位系统中指针占4字节，unsigned int最大值是Oxffffffff

unsigned int mrsp = packet get int();//mrsp是来自用户的数据

/*关

攻击者可通过让(mrsp+num)值为0xffffffff/4+1=1073741825,即mrsp=1073740825,造成整型溢出

*(mrsp+num)* sizeof(char*)等效于1073741825*4,溢出后求模后值为4,即为response分配了4字节

的空间

*循环次数为1073740825次，用户数据将覆盖大量的内存空间

**/

char* response = malloc((mrsp+ num)*sizeof(char*));

unsigned int i;

for(i=0;i<mrsp;i++)

response[i]= packet get string();

unsigned int num;//本例中num值为1000

void example fun()

//本例代码假设是运行在32位的系统中

unsigned int mrsp = packet get int();//mrsp是来自用户的数据

if(mrsp>0& .& .UINT MAX- num> mrsp)//运算前验证mrsp

char* response = malloc((mrsp+ num)* sizeof(char*));

unsigned int i;

for(i=0;i<mrsp;i++)

response[i]= packet get string();

void write wrong msg(char*); //将错误消息呈现到用户界面

void example fun()

const char* PATH="C:\\config.txt";

File* file = fopen(PATH,"rw");

if(!file)

char msg[128]="Error:";

strcat(msg,PATH);

streat(msg,"does not exist.");

write wrong msg(msg);//输出配置目录的完整路径名

void write wrong msg(char*);//将错误消息呈现到用户界面

void example fun()

{

const char PATH="C:\\config.txt";

File* file = fopen(PATH,"rw");

if(!file)

char msg[128]="Sorry! We will fix the problem soon!";

write wrong msg(msg);//不输出敏感信息

int is trusted(char*,char*);//判断用户名口令是否正确，均正确则返回1,否则返回0

void write log(charx);//将消息写入日志文件

void data visit(char* username,char* password)//username和password为用户输入数据，均不超过10个

字符

{

if(is trusted(username,password)) //用户名和口令正确时调用write log()写入日志

char msg[64];

strcat(msg,username);

strcat(msg," and ");

strcat(msg,password);

strcat(msg," correct!");

write log(msg);//msg中包含敏感信息

//执行访问数据等操作

int is trusted(char*,char*);//判断用户名口令是否正确，均正确则返回1,否则返回0

void write log(char*);//将消息写入日志文件

void data visit(char* username, char* password)//username和password为用户输入数据，均不超过10个 字符

if(is trusted(username, password))

char* msg ="Login success!"; //msg中不包含敏感信息

write log(msg);

//执行访问数据等操作

void init address book() //地址簿初始化

{

char bookid[8];//地址簿id

char bookpath[64];//地址簿存放路径

···

//生成调试日志

CCLOG("AddressBookID:%s\n",bookid);

CCLOG("Path:%s\n",bookpath);

···

void init address book()//地址簿初始化

char bookid[8];//地址簿id

char bookpath[64]; //地址簿存放路径

…

//程序发布之前将调试代码注释或删除掉

/* CCLOG("AddressBookID:%s\n",bookid);

CCLOG("Path:%s\n",bookpath);

void example fun(int count)//count为用户输入数据

int i;

if(count>0)//未检查count的值是否过大可能导致软件循环过多而使软件拒绝服务

for(i=0;i<count;i++)

int MAX COUNT=1000;//本例中定义循环次数最大为1000次

void example fun(int count)//count为用户输入数据

int i;

if(count>0 &.&.count<=MAX COUNT)//判断循环次数是否不大于最大循环次数

for(i=0;i<count;i++)

int get memory(char* ptr ,int new size)

ptr = realloc(ptr,new size);//使用realloc()重新分配内存之前未清空该内存块信息

if(ptr)

return 1;

else

return 0;

int get memory(char* ptr ,int new size)

memset(ptr,0,strlen(ptr)); //使用memset()置0

ptr = realloc(ptr,new size);

if(ptr)

return 1;

else

return 0:

#include<stdlib.h>

void example fun(char* parameter)//parameter长度不超过20个字符

char * password ="";//password用于存放敏感信息

password =(char *)malloc(30 * sizeof(char));

if(password!= NULL)

strcpy(password, parameter);//password指向的内存未锁定

#include <stdlib.h>

#include(windows.h)

void example fun(char* parameter)//parameter长度不超过20个字符

char * password="";//password用于存放敏感信息

password =(char *)malloc(30* sizeof(char));

if(password!= NULL)

if(VirtualLock(password,30))//锁定password指向的内存，并检查返回值确保锁定操作执行正确

strcpy(password, parameter);

… ·

VirtualUnlock(password,30);//解锁内存

class CTest

private:

char secret[MAX SIZE]=“abcd”;

public:

char[] get value()

return secret;

class CTest

private;

char[] get value()

memcpy(cpy secret,secret,sizeof(secret));//创建私有数组的副本

return cpy secret;

void store password(char*); //将口令存入数据库

void example fun(char* password)

store password(password); //明文存储口令

#include "sha.h"

using namespace CryptoPP;

int encrypt(char* input,char* output) //加密函数，输出参数返回加密后的字符串

SHA256 sha256;

int r= sha256.enc(input,output);//加密算法，对input加密(为确保此处安全，最好使用不可逆加密算法)

void store password(char*); //将口令存入数据库

void example fun(char* password)

·

char psw[1024]={0};

intr = encrypt(password,psw); //加密 password

store password(psw); //存储加密后的 psw

··

#include "aes.h"

using namespace CryptoPP;

int encryptor(char* input,char* output)//加密函数，输出参数返回加密后的字符串

AESEncryption aesEncryptor;

int r = aesEncryptor.enc(input,output);//使用双向可逆的AES加密算法

… ·

void store password(char*);//将口令存放到数据库中

void example fun(char* password)

…

char psw[10247={0};

int r=encryptor(password,psw);//加密password

store password(psw); //存放加密后的psw

··

#include "sha.h"

using namespace CryptoPP;

int encrypt(char* input,char* output)//加密函数，输出参数返回加密后的字符串

SHA256 sha256;

int r= sha256.enc(input, output);//使用单向不可逆的SHA256加密算法

void store password(char*);//将口令存放到数据库中

void example fun(char* password)

···

char psw[1024]={0};

intr = encryptor(password,psw);//加密password

store password(psw);//存放加密后的psw

int psw is correct(char* password)//判断口令是否正确，是则返回1,不是则返回0

if(strcmp(password,"jk46k643h9gj9iwd63")==0) //代码中包含硬编码口令

return 1;

return 0;

#include "sha.h"

using namespace CryptoPP;

int encryptor(char* input,char* output)//加密函数，输出参数返回加密后的字符串

{

SHA256 sha256;

int r = sha256.enc(input, output);

char* get psw(void);//从数据库获得口令

int psw is correct(char* password)//判断口令是否正确，是则返回1,不是则返回0

·

char* psw = get psw();

char hpsw[1024]={0};

intr = encryptor(password,hpsw);//加密password

if(strcmp(hpsw,psw)==0)//判断加密后得到的hpsw与数据库中存储的psw是否相同

return 1;

return 0:

void send message(char*);//将传进来的字符串发送出去

void example fun(char* address) //address是用户的敏感信息

send message(address);//传输address前没有进行加密

#include "aes.h"

using namespace CryptoPP;

void send message(char*);//将传进来的字符串发送出去

int encryptor(charx input,char* output) //加密函数，输出参数返回加密后的字符串

AESEncryption aesEncryptor;

int r = aesEncryptor.enc(input,output);

void example fun(char* address)//address是用户的敏感信息

intr = encryptor(address,addr); //加密address

send message(addr); //传输加密得到的addr

#include "des.h"

using namespace CryptoPP;

int get key(unsigned char[]);//从安全存储中取密钥

int encryptor(charx input, unsigned char output[])

//使用加密强度较低的DES加密算法

unsigned char key[DES::KEYLENGTH];

DESEncryption desEncryptor;

int r = get key(key);

…

desEncryptor.SetKey(key,DES::KEYLENGTH);//设置密钥

desEncryptor.ProcessBlock(input,output);//加密input并保存到output中

return output;

#include"aes.h"

using namespace CryptoPP;

int get key(unsigned char[]);//从安全存储中取密钥

int encryptor(char* input, unsigned char output[])

//使用加密强度较高的AES加密算法

unsigned char key[AES::BLOCKSIZE];

AESEncryption aesEncryptor;

unsigned char xorBlock[AES::BLOCKSIZE];

memset(xorBlock,0,AES::BLOCKSIZE);

int r = get key(key);

…

aesEncryptor.SetKey(key,AES::DEFAULT KEYLENGTH);//设置密钥

aesEncryptor.ProcessAndXorBlock(input,xorBlock,output);//加密input并保存到output中

return output;

#include"sha.h"

using namespace CryptoPP;

int encryptor(char* input,char* output)//加密函数，输出参数返回加密后的字符串

SHA1 shal;

int r = shal.enc(input,output);//使用SHA1散列加密算法

#include"sha.h"

using namespace CryptoPP;

int encryptor(char* input,char* output) //加密函数，输出参数返回加密后的字符串

SHA256 sha256;

int r = sha256.enc(input,output); //使用SHA256 标准散列加密算法

#include "aes.h"

using namespace CryptoPP;

int key size = 8;

char* encryptor(char* input)

unsigned char key[key size];

unsigned char iv[]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08};

·

CBC Mode<AES)::Encryption Encryptor(key,key size,iv);//使用固定的初始化向量

…

#include<wincrypt.h)

#include "aes.h"

using namespace CryptoPP;

int key size =8;

char* encryptor(char * input)

HCRYPTPROV hcryptprov;

unsigned char key[key size];

unsigned char iv[key size];

… ·

if(CryptGenRandom(hcryptprov,EVP MAX IV LENGTH,iv))//使用随机的初始化向量

CBC Mode<AES>::Encryption Encryptor(key, key size,iv);

void example fun()

int i,num;

unsigned char iv[8];

for(i=0;i<8;i++)

num =10*rand()/(RAND MAX+1);//使用不充分的伪随机数生成器

iv[i]=num+0;

#include<wincrypt.h)

void example fun()

HCRYPTPROV hcryptprov;

unsigned char iv[8];

if(CryptGenRandom(heryptprov,8,iv))//基于加密的伪随机数生成器CSPRNG

#include<arpa/inet.h)

#include<winsock.h)

int is trusted(char* address)//验证主机是否值得信任

struct hostent *hp;

char* trustedHost ="trustme.com";

struct in addr myaddress;

myaddress,s addr = inet addr(address);//将address转换成32位Ipv4地址

//通过反向解析获取myaddr地址的域名

hp = gethostbyaddr((char )&.myaddress.s addr,sizeof(in addr),AF INET);

//通过域名对主机进行身份鉴别

//攻击者可通过 DNS 欺骗绕过依赖域名的主机身份鉴别

if(hp&.&. ! strncmp(hp->h name,trustedHost, sizeof(trustedHost)))

return 1;

else

return 0;

int is true(char*,charx);//判断用户名口令是否正确，是则返回1,否则返回0

int is trusted(char* username, char* password)//验证主机是否值得信任

{

//通过用户名口令对主机进行身份鉴别

return is true(username, password);

void set password(string);//存储用户输入的口令

void init user(string username, string password)

set password(password);//口令强度可能不足

string username;//用户名

string[] passwordlist; //口令表

string create password date; //口令创建的时间

int password outdate days;//口令过期天数(可配置)

boolean user exists(string,string);//判断用户名口令是否正确

void set password(string); //存储用户输入的口令

int check length(string); //口令长度检测，符合要求返回1,否则返回0

int check mode(string); //口令是否包含字母，数字和特殊字符，缺少其中一种或以上表示口令强度弱

//全部包含返回1,否则返回0

int check exclude name(string); //口令是否不包含用户名，不包含返回1,否则返回0

int check time(string); //通过比较当前时间和口令创建时间判断口令是否过期

//未过期返回1,否则返回0

int check is used(string); //通过查询口令表判断口令是否曾经使用过，未使用过返回1,否则返回0

···

int check password level(string password) // 口令强度检测

if(check length(password)==0)

cout<<" 口令长度不符合要求!"<<endl;

return 0;

if(check mode(password)==0)

cout<<" 口令组合等级弱!"<<endl;

return 0;

if(check exclude name(password)==0)

cout<<" 口令包含用户名!"<<endl;

return 0;

if(check is u sed(password)==0)

cout<<" 口令曾经使用过!"<<endl;

return 0;

return 1;

void init u ser(string username,string password){

…

if(check password level(password)) //检测 password 的口令强度

set password(password);

else

//用户登录时自动判断密码使用期限并提示用户更新密码

void check user(string username, string password)

if(user exists(username,password)) //身份鉴别

if(!check time(password))//检测password是否过期

//提示用户密码已过期，建议其修改密码

··

else

void example fun()

char password[MAX STR LEN];//MAX STR LEN的值为15

inti=0;

charc=*0;

printf("Please enter the password:");

while(i<MAX STR LEN &.&.c!=\n)

scanf("%c",&.c);//没对用户输入的口令进行掩饰

password[i]= c;

i++;

void example fun()

{

char password[MAX STR LEN];//MAX STR LEN的值为15

inti=0;

char c=0;

printf("Please enter the password:");

while(i<MAX STR LEN &.&. (c=getch())!=\n)

password[i]= c;

putchar(*);//用星号代替用户所输入的口令

i++;

#include<stdio.h>

#include<string.h)

char username[16];//用户名

·

int sql compare(char*);//判断字符串是否符合构建sql语句的要求，是则返回1,否则返回0

void sqlquery(char* staffID) //staffID为用户输入数据，不超过10个字符

if(sql compare(staffID))

char sqlQuery[64]="SELECT* FROM employee WHERE staffID='";

strcat(sqIQuery,staffID);//用户输入的staffID可能不在其访问权限内

streat(sqIQuery,"");

//在数据库中执行sqlQuery语句

#include<stdio.h)

#include<string.h)

char username[16];//用户名

int sql compare(char*);//判断字符串是否符合构建sql语句的要求，是则返回1,否则返回0

char* find departID(char*);//根据用户名返回其所在部门的部门ID

void sql query(char* staffID)//staffID为用户输入数据，不超过10个字符

if(sql compare(staffID))

//查询语句增加部门ID查询条件

char sqlQuery[64]="SELECT FROM employee WHERE staffID=";

strcat(sqlQuery, staffID);

strcat(sqIQuery,"and DepartID='");

strcat(sqlQuery, find departID(username));

streat(sqIQuery,"");

//在数据库中执行sqIQuery语句

#include "sha.h"

using namespace CryptoPP;

int encryptor(char* input,char* output)//加密函数，输出参数返回加密后的字符串

SHA256 sha256;

int r = Sha256.enc(input,output);

void example fun(char* password)//password最大长度为20个字符

char psw[1024]={0};

intr = encryptor(password,psw);//仅使用单向加密，还是容易被攻击者用彩虹表等方式破解口令

//将加密得到的psw字符串存储到数据库中

#include "sha.h"

#include "aes.h"

using namespace CryptoPP;

int encryptor(char* input,char* output)//加密函数，输出参数返回加密后的字符串

SHA256 sha256;

int r = Sha256.enc(input, output);

· ·

void send salt(char* salt)//用AES算法加密盐值后传输到另一台服务器上

AESEncryption aesEncryptor;

char output[1024]={0};

int r = aesEncryptor.enc(salt, output);

//发送加密后盐值(output)到另一台服务器上

·

char* random str(int);//随机生成字符串

int saltLength = 20;

void example fun(char* password)//password最大长度为20个字符

char* salt = random str(saltLength);//获得一个长度为saltLength的随机字符串

char str[64];

strcat(str,password);

strcat(str,salt); //加入salt值

char psw[1024]={0};

int r= encryptor(str,psw);//为攻击者破解口令增加难度

//将加密得到的psw字符串存储到数据库中

//将salt字符串加密后存储到另一台服务器的数据库中

send salt(salt);

…

#include "rsa.h"

using namespace CryptoPP;

int encryptor(char* input,char* output)//加密函数，输出参数返回加密后的字符串

RSAES PKCS1v15 Encryptor rsapkcsl;//使用Pkcs1填充

int r = rsapkesl.enc(input, output);

#include"rsa.h"

using namespace CryptoPP;

int encryptor(char input,char* output)//加密函数，输出参数返回加密后的字符串

RSAES OAEP SHA Encryptor rsaoaep; //使用OAEP加密填充

int r= rsaoaep.enc(input, output);

#include<Winlnet.h)

void write html(const charx,const char*);

int example fun(int argc,char ** argv)

//创建一个Internet连接

HINTERNET example =

NULL,NULL,0);

//将参数1的字符串写入参数2指定网页的函数

InternetOpen("TextExample",INTERNET OPEN TYPE PRECONFIG,

#include<WinInet.h)

void write html(const char×,const char*);//将参数1的字符串写入参数2指定网页的函数 char * verification(const char *);//验证参数，若参数不合法则转义成合法字符串后返回

int example fun(int argc,char * argv)

//创建一个Internet连接

HINTERNET example = InternetOpen("TextExample",INTERNET OPEN TYPE PRECONFIG,

NULL,NULL,0);

……

char * name = getPar(argv,'name);//name来源于默认为不可信任的外部输入

write html(verification(name),"index.html");//name在输出前已进行验证或转义

…

InternetCloseHandle(example);//关闭Internet连接

return 0;

测试阶段

人员角色

职 责

时间(工作日)

工作成果

硬件环境

软件环境

测试用例编号

YMLD-YL-2016-1001-0001

测试记录编号

YMLD-JL-2016-1001-0001

序号

测试内容

测试结果

备注